/* eslint-disable no-unused-vars */
import axios from 'axios'
import Vue from 'vue'
import { parseCallData } from './callData'
import responseCode from './codes/responseCode'
import agentStatus from './codes/agentStatus'
import events from './events'
import {
  Notification
} from 'element-ui'
const duration = 1000 // 消息显示时长
function notifySuccess(message = '', title = '成功') {
  Notification({
    type: 'success',
    message,
    title,
    duration
  })
}
function notifyInfo(message = '', title = '提示') {
  Notification({
    type: 'info',
    message,
    title,
    duration
  })
}
function notifyWarn(message = '', title = '警告') {
  Notification({
    type: 'warning',
    message,
    title,
    duration
  })
}
function notifyError(message = '', title = '错误') {
  Notification({
    type: 'error',
    message,
    title,
    duration
  })
}

// 令牌
let Token = null

export const ajax = axios.create({
  baseURL: process.env.VUE_APP_CALL_PROXY_URL2,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json;charset:UTF-8'
  }
})
ajax.interceptors.request.use(cnf => {
  if (Token) {
    if (!cnf.headers) {
      cnf.headers = {}
    }
    cnf.headers['Token'] = Token
  }
  return cnf
}, e => {
  if (e.config.showError) {
    notifyError('请求出错！请重试！')
  }
})
// 成功
const successCode = [0, '0']
ajax.interceptors.response.use(res => {
  const { retcode } = res.data
  if (successCode.includes(retcode)) {
    if (res.headers['token'] || res.headers['Token']) {
      Token = res.headers['token'] || res.headers['Token']
    }
    res.data.data = res.data.result ?? {}
    console.log('【响应】', res.data)
    return res.data
  }

  if (res.config.showError) {
    notifyError(res.data.message || responseCode[retcode])
  }
  return Promise.reject(res.data)
}, e => {
  if (e.config.showError) {
    notifyError('发生错误！')
  }
  return Promise.reject(e)
})

// 话务条服务
export class CallProxyService {
  vdnId = '' // 虚拟呼叫中心id
  agentId = '' // 坐席
  role = '' // 角色
  skills = '' // 签入的技能

  stop = false // 是否停止轮询
  password = '' // 密码
  phonenum = '' // 分机号
  interval = 600
  status = 0 // 当前状态
  callData={} // 随路数据
  callId = '' // 当前通话id
  callPlatform = '02'
  constructor() {
    this.bus = new Vue()
    // 签出成功停止轮询
    this.on('OnSignOutSuccess', () => this.stopPolling())
  }
  /** 绑定事件
   * @params {string} event 事件名称
   * @params {function} callback 处理函数
   */
  on(event, callback) {
    if (event instanceof Array) {
      for (const e of event) {
        this.bus.$on(e, callback)
      }
    } else {
      this.bus.$on(event, callback)
    }
  }
  /** 绑定once */
  once(event, callback) {
    if (event instanceof Array) {
      for (const e of event) {
        this.bus.$once(e, callback)
      }
    } else {
      this.bus.$once(event, callback)
    }
    // this.bus.$once(event, callback)
  }
  /** 解绑事件
   * @params {string} event 事件名称
   * @params {function} callback 处理函数
   */
  off(event, callback) {
    if (event instanceof Array) {
      for (const e of event) {
        this.bus.$off(e, callback)
      }
    } else {
      this.bus.$off(event, callback)
    }
    // this.bus.$off(event, callback)
  }
  /** 手动触发事件
   * @params {string} event 事件名称
   * @params {any} data 回调参数
   */
  emit(event, data) {
    this.bus.$emit(event, data)
  }
  /** 设置参数
   * @params {number} interval 轮询时间间隔
   * @params {string} agentId 工号
   * @params {string} password 密码
   * @params {string} phonenum 分机号
   */
  setParam(interval, agentId, password, phonenum) {
    this.agentId = agentId || ''
    this.password = hex_hmac_md5(agentId, password || 'cti-1234')
    this.phonenum = phonenum || ''
    this.interval = interval || 1000 // 轮询间隔时间
    this.stop = false // 是否停止轮询
  }

  // 停止轮询
  stopPolling() {
    this.stop = true
    clearTimeout(this.timerID)
  }
  // 开始轮询
  startPolling() {
    this.stop = false
    this.eventPolling()
  }
  // 轮训监听坐席事件
  eventPolling() {
    this.timerID = setTimeout(() => {
      this.agentEvent().finally(() => {
        if (!this.stop) {
          this.eventPolling()
        }
      })
    }, this.interval || 200)
  }
  // 监听坐席事件,并分发
  agentEvent() {
    return ajax.request({
      url: `/cclog/agentevent/${this.agentId}`,
      showError: true,
      method: 'GET'
    }).then(res => {
      res.data = res.event ?? {}
      if (this.callData && !res.data.callData) {
        res.callData = this.callData // 添加随路数据
        res.data.callData = this.callData
      }
      if (res.data.content && res.data.content.callId) {
        res.data.content.callid = res.data.content.callId
      }
      const eventName = res.event?.eventType
      if (eventName) {
        let eventList = events[eventName] ?? []
        if (typeof eventList === 'string') {
          eventList = [eventList]
        }
        console.log(`${eventName} => ${eventList.join(',')}`, res)
        eventList.forEach(name => {
          this.bus.$emit(name, res)
        })
      }
    }).finally(r => {
      return Promise.resolve(r)
    })
  }
  // 设置callid
  setCallId(callId) {
    this.callId = callId
  }
  /** 根据状态码获取坐席对应状态
   * @params {number} status 坐席状态
   * @returns {string}
   */
  getStatusText(status) {
    if (status === null || status === undefined) return ''
    return agentStatus[status] || ''
  }

  /** 签入
   * @params autoanswer 是否自动应答，默认为 true
   * @params autoenteridle 是否自动进入空闲态，默认为 true
   * @params disableNoAnswerForceBusy 是否禁用无应答强制示忙，默认为false
   * @params password 坐席密码 true string
   * @params phonenum 签入的电话号码 true string
   * @params status 签入后的状态，默认为空闲态。4：空闲，5：整理态false integer(int32
   */
  signIn(autoanswer, autoenteridle, disableNoAnswerForceBusy, status) {
    const data = {
      password: this.password,
      phonenum: this.phonenum,
      autoanswer,
      autoenteridle,
      disableNoAnswerForceBusy,
      status
    }
    return ajax.request({
      url: `/nagent/online/${this.agentId}`,
      showError: true,
      method: 'POST',
      data
    }).then(res => {
      // agentId 座席 id integer(int32)
      // agentName 座席姓名 string
      // agentRelease 座席主动挂断次数 integer(int32)
      // autoanswer 是否自动应答 boolean
      // autoenteridle是自动进入空闲态 boolean
      // createTime 创建时间 string(date-time)
      // loginDate 登录时间 integer(int64)
      // maxChatNum 文字最大服务数 integer(int32)
      // modifyTime 修改时间 string(date-time)
      // password 登录密码 string
      // phonenum 电话号码 string
      // role 角色 integer(int32)
      // skills 配置的技能 string
      // status      签入后的状态，默认为空闲态。4：空闲，      5：整理态      integer(int32)
      // vdnId 租户 ID integer(int32)
      const { result } = res
      this.agentId = result?.agentId
      this.agentName = result?.agentName
      this.phonenum = result?.phonenum
      this.role = result?.role
      this.skills = result?.skills
      this.vdnId = result?.vdnId

      this.startPolling() // 开始轮询
      // 定时刷新token
      this.refreshTokenId = setInterval(() => this.refreshToken(), 60000)
      return Promise.resolve(res)
    })
  }
  /** 强制签入
   *@params {boolean} autoanswer   是否自动应答，默认   为 true   false boolean
   *@params {boolean} autoenteridle   是否自动进入空闲   态，默认为 true   false boolean
   *@params {boolean} disableNoAnswerForceBusy   是否禁用无应答强   制示忙，默认为   false   false boolean
   *@params {number} status   签入后的状态，默认   为空闲态。4：空闲，   5：整理态   false integer(int32)
   */
  forceSignIn(autoanswer, autoenteridle, disableNoAnswerForceBusy, status) {
    const data = {
      password: this.password,
      phonenum: this.phonenum,
      autoanswer,
      autoenteridle,
      disableNoAnswerForceBusy,
      status
    }
    return ajax.request({
      url: `/nagent/online/${this.agentId}/forcelogin`,
      showError: true,
      method: 'POST',
      data
    }).then(res => {
      // agentId 座席 id integer(int32)
      // agentName 座席姓名 string
      // agentRelease 座席主动挂断次数 integer(int32)
      // autoanswer 是否自动应答 boolean
      // autoenteridle是自动进入空闲态 boolean
      // createTime 创建时间 string(date-time)
      // loginDate 登录时间 integer(int64)
      // maxChatNum 文字最大服务数 integer(int32)
      // modifyTime 修改时间 string(date-time)
      // password 登录密码 string
      // phonenum 电话号码 string
      // role 角色 integer(int32)
      // skills 配置的技能 string
      // status    签入后的状态，默认为空闲态。4：空闲，      5：整理态      integer(int32)
      // vdnId 租户 ID integer(int32)

      const { result } = res
      this.agentId = result?.agentId
      this.agentName = result?.agentName
      this.phonenum = result?.phonenum
      this.role = result?.role
      this.skills = result?.skills
      this.vdnId = result?.vdnId

      this.startPolling() // 开始轮询
      // 定时刷新token
      this.refreshTokenId = setInterval(() => this.refreshToken(), 60000)
      return Promise.resolve(res)
    })
  }

  /** 强制签入不绑定话机
   *@params {string} phonenum	N	签入座席使用的电话
   *@params {boolean} autoanswer	N	是否自动应答，默认为true
   *@params {boolean} autoenteridle	N	是否自动进入空闲态，默认为true。
   *@params {boolean} releasephone	N	座席挂机后是否进入非长通态：默认为false
   *@params {number} status	N	签入后的状态，默认为空闲态。4：空闲，5：整理态。
   *@params {number} agenttype	N	签入的座席类型，默认为4。4：pc+phone座席，11：pc+phone视频座席
   *
   */
  forceLoginExWithoutPhone(phonenum, autoanswer, autoenteridle, releasephone, status, agenttype) {
    return Promise.reject('未实现')
  }
  // 签出
  signOut() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/logout`,
      showError: true,
      method: 'POST'
    }).then(res => {
      // this.agentId = ''
      this.agentName = ''
      // this.phonenum = ''
      this.role = ''
      this.skills = ''
      this.vdnId = ''
      clearInterval(this.refreshTokenId)
      this.stopPolling() // 结束轮询
    })
  }
  // 强制签出，带原因
  forcelogoutwithreason(reason) {
    // return Promise.reject('未实现')
    return this.signOut()
  }
  /** 示忙
   * @params reason reason query false string
   */
  sayBusy(reason) {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/saybusy`,
      showError: true,
      method: 'POST',
      params: { reason }
    })
  }
  /** 示闲 */
  sayFree() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/sayfree`,
      showError: true,
      method: 'POST'
    })
  }
  /** 呼叫应答 */
  answer() {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/answer`,
      showError: true,
      method: 'POST'
    })
  }
  /** 挂断呼叫
   * @params hangUpCustomer 坐席振铃拒接是否挂断客户 query false string
  */
  release(hangUpCustomer) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/release`,
      showError: true,
      method: 'POST',
      params: { hangUpCustomer }
    })
  }
  /** 开始静音 */
  beginMute() {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/beginmute`,
      showError: true,
      method: 'POST'
    })
  }
  /** 取消静音 */
  endMute() {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/endmute`,
      showError: true,
      method: 'POST'
    })
  }
  /** 呼叫保持 */
  hold() {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/hold`,
      showError: true,
      method: 'POST'
    })
  }
  /** 取消保持 */
  unHold(callId) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/gethold`,
      showError: true,
      method: 'POST',
      params: { callId }
    })
  }
  /**
   * 外呼
   * @params callappdata 随路数据内容 false string
   * @params called 外呼号码 true string
   * @params caller 坐席工号或主叫显示号码 true string
   * @params mediaability  媒体能力，默认为 0。0：  音频，1：视频  false integer(int32)
   * @returns
   */
  callOut(called, caller, callappdata, mediaability) {
    if (typeof called === 'string') {
      called = called.trim()
    }
    if (typeof callappdata === 'object') {
      callappdata = JSON.stringify(callappdata)
    }
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/callout`,
      showError: true,
      method: 'POST',
      data: {
        called, caller, callappdata, mediaability
      }
    }).then(res => {
      const result = res.result ?? res.data
      res.data = {}
      res.data.callid = result
      return res
    })
  }
  /** 内部呼叫
   * @params callappdata 随路数据内容 false string
   * @params called 外呼号码 true string
   * @params mediaability 媒体能力，默认为 0。0：音频，1：视频 false integer(int32)
   * @returns
   */
  callInner(called, callappdata, mediaability) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/callinner`,
      showError: true,
      method: 'POST',
      data: {
        called, caller: this.phonenum, callappdata, mediaability
      }
    })
  }
  /** 重新设置技能队列
   * @params {string} 是否自动签入配置的技能标志，true 为自动签入座席所配置技能path true string
   * @params {string} 数必选，为技能队列 ID 字符串组，例如 1;2;3，座席签入的技能队列为此 id 和所配置的交集）query true string
   */
  changeAgentSkill(autoflag, skillId) {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/resetskill/${autoflag}`,
      showError: true,
      method: 'POST',
      params: {
        skillId
      }
    })
  }
  /** 进入工作状态 */
  agentEnterWork() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/work`,
      showError: true,
      method: 'POST'
    })
  }
  /** 退出工作状态 */
  agentEnterIdle() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/cancelwork`,
      showError: true,
      method: 'POST'
    })
  }
  /** 开始录音
   * @params {string} filename N 录音盘符
   */
  beginRecord(filename = null) {
    return Promise.reject('未实现')
  }
  /** 停止录音 */
  stopRecord() {
    return Promise.reject('未实现')
  }
  /** 开始放音
   * @params {string} agentId 坐席工号 false string
   * @params {number} did 呼叫显示号码 false string
   * @params {number} filePath 文件路径 false string
   */

  beginPlay(filePath) {
    return ajax.request({
      url: `/nagent/resource/recordplay/${this.agentId}/playbyphone`,
      showError: true,
      method: 'POST',
      data: {
        agentId: this.agentId, did: this.phonenum, filePath
      }
    })
  }
  /** 停止放音
   * @params agentId 目标坐席工号 false string
   * @params callId 通话 callId true string
   * @params file 文件路径，文件目录是文件服务器/mua_ext 目录下false string
   */
  stopPlay(file, agentId, callId) {
    return ajax.request({
      url: `/nagent/resource/recordplay/${this.agentId}/stopplay`,
      showError: true,
      method: 'POST',
      data: {
        file, agentId, callId
      }
    })
  }
  /** 暂停放音
   * @params agentId 目标坐席工号 false string
   * @params callId 通话 callId true string
   * @params file   文件路径，文件目录是文件服务器  /mua_ext 目录下false string
  */
  pausePlay(file, agentId, callId) {
    return ajax.request({
      url: `/nagent/resource/recordplay/${this.agentId}/pauseplay`,
      showError: true,
      method: 'POST',
      data: {
        file, agentId, callId
      }
    })
  }
  /** 恢复放音
   * @params agentId 目标坐席工号 false string
   * @params callId 通话 callId true string
   * @params file   文件路径，文件目录是文件服务器  /mua_ext 目录下false string
  */
  resumePlay(file, agentId, callId) {
    return ajax.request({
      url: `/nagent/resource/recordplay/${this.agentId}/resumeplay`,
      showError: true,
      method: 'POST',
      data: {
        file, agentId, callId
      }
    })
  }
  /** 放音快进
   * @params {number} time	Y	快进的时长（范围为1-9999999999999）
   */
  foreFastPlay(time) {
    return Promise.reject('未实现')
  }
  /** 放音快退
   * @params {number} time	Y	快退的时长（范围为1-9999999999999）
   */
  backFastPlay(time) {
    return Promise.reject('未实现')
  }
  /** 呼叫转移
   * @params {number} devicetype 转移设备类型，技能队列为 1，坐席为 2，IVR 为 3，系统接入码为 4，外部号码为 5 true integer(int32)
   * @params {string} address 转移地址，即转移设备类型对应的设备ID，转外线时是对方号码true string
   * @params {number} mode 转移模式：释放转为true integer(int32) 0(支持：技能、坐席、IVR、系统接入码、外线)，挂起转为 1(支持：IVR)，成功转为2(支持：技能、坐席、接入码、外线)，通话转为 3(支持：外线)，三方转为4(支持：外线)
   * @params {string} callappdata 需设置的随路数据。内容可为空false string
   * @params {string} caller 主叫号码 false string
   * @params {number} mediaability 媒体能力。（默认为0。0：音频，1：视频。在转外部号码时有效，其他方式的转移根据座席的类型来判断是否带媒体能力）false integer(int32)
   */
  transfer(devicetype, address, mode, callappdata, caller, mediaability) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/transfer`,
      showError: true,
      method: 'POST',
      data: {
        devicetype, address, mode, callappdata, caller, mediaability
      }
    })
  }
  /** 挂断话机
   * @params hangUpCustomer 坐席振铃拒接是否挂断客户 query false string
   */
  releasePhone(hangUpCustomer) {
    return this.release(hangUpCustomer)
  }
  /** 发送便签
   * @params callId 文字交谈的会话 ID，不能为空，长度不能超过 30 个字符 false string
   * @params chatId 当前发送内容的唯一编号。当 needCheck为 true 时，该参数生效。对端收到座席发送的内容后，会回复一个确认消息，该chatId 会在确认消息中返回 false integer(int32)
   * @params content 文字交谈的内容不能为空，长度不能超过6144 个字符false string
   * @params needCheck 是否需要对端发送确认消息false string
   */
  sendMessage(callId, chatId, content, needCheck) {
    return ajax.request({
      url: `/nagent/textchat/${this.agentId}/chatmessage`,
      showError: true,
      method: 'POST',
      data: {
        callId, chatId, content, needCheck
      }
    })
  }
  /** 查询呼叫随路数据
   *
   */
  queryCallData() {
    return ajax.request({
      url: `/nagent/calldata/${this.agentId}/callinfo`,
      showError: true,
      method: 'GET'
    }).then(res => {
      if (!res.result.callData) {
        return {
          data: {
            calldata: this.callData || {}
          }
        }
      }
      if (!/\^/.test(res.result.callData)) {
        try {
          Object.assign(this.callData, JSON.parse(res.data.callData))
        } catch (e) {
          console.log(e)
        }
      } else {
        try {
          Object.assign(this.callData, parseCallData(res.result.callData))
        } catch (e) {
          console.log(e)
        }
      }
      return Promise.resolve({
        data: {
          calldata: this.callData
        }
      })
    })
  }
  /** 设置呼叫随路数据
   * @parmas {string} callId 呼叫 callId true string
   * @parmas {string} callData 随路数据内容 false string
   */
  setCallData(callId, calldata) {
    return ajax.request({
      url: `/nagent/calldata/${this.agentId}/setcalldata`,
      showError: true,
      method: 'POST',
      data: {
        callId, calldata
      }
    })
  }
  /** 查询保持列表 */
  holdlist() {
    return ajax.request({
      url: `/nagent/calldata/${this.agentId}/holdlist`,
      showError: true,
      method: 'GET'
    })
  }
  /** 查询坐席可用配置技能队列
   * @params {string} workno Y 指定坐席工号
   */
  queryTotalSkills() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/agentskills`,
      showError: true,
      method: 'GET'
    })
  }
  /** 查询指定座席详细座席信息
   * @params {string} targetAgentId Y 指定坐席工号
   */
  queryAgentInfoByWorkNo(targetAgentId) {
    return ajax.request({
      url: `/nagent/device/agent/${this.agentId}/agentbyagentid/${targetAgentId}`,
      showError: true,
      method: 'GET'
    }).then(res => {
      res.data = res.result
      this.status = res.result.status
      res.data.skillList.forEach(e => {
        e.id = e.skillId
        e.name = e.skillName
      })
      res.data.skilllist = res.data.skillList
      return res
    })
    // return ajax.request({
    //   url: `/nagent/device/agent/${this.agentId}/agentskill/${targetAgentId}`,
    //   method: 'GET'
    // }).then(res => {
    //   res.data = {
    //     skilllist: res.result?.map(e => {
    //       return {
    //         id: e.skillId,
    //         name: e.skillName
    //       }
    //     }) ?? []
    //   }
    //   return res
    // })
  }
  /** 查询所在VDN所有座席当前状态信息 */
  queryAgentInfo() {
    return ajax.request({
      url: `/nagent/device/agent/${this.agentId}/allagentstatus`,
      showError: true,
      method: 'GET'
    })
  }
  /** 查询指定技能队列排队等待呼叫信息
   * @params {number} skillId	Y	被查询技能队列ID
   */
  queryQueueInfo(skillId) {
    return ajax.request({
      url: `/nagent/device/skill/${this.vdnId}/${skillId}/waitinfo`,
      showError: true,
      method: 'POST'
    }).then(res => {
      res.data = {
        waitcallinfo: {
          length: res.result?.callWaitNums ?? 0
        }
      }
      return res
    })
  }
  /** 内部求助
   *@params {string} dstaddress	求助对象，座席工号或技能队列   ID   true string
   *@params {number} devicetype	求助设备类型，技能队列为 1，座   席工号为 2，默认为 2   false integer(int32)
   *@params {number} mode	求助模式，两方求助为 1，三方求   助为 2，默认为 1   false integer(int32)
   *@params {string} callappdata	需设置的随路数据。内容可为空 false string
   */
  consult(dstaddress, devicetype, mode, callappdata) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/innerhelp`,
      showError: true,
      method: 'POST',
      data: {
        dstaddress, devicetype, mode, callappdata
      }
    })
  }
  /** 三方通话
   *@params {string} callId 呼叫 callId true string
   *@params {string} callData 随路数据内容 false string
   */
  confjoin(callId, callData) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/confjoin`,
      showError: true,
      method: 'POST',
      data: {
        callId, callData
      }
    })
  }
  /** 拆除指定呼叫
   * @params {string} callId Y	待拆除的呼叫callid
   */
  releaseCall(callId) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/dropcall/${callId}`,
      showError: true,
      method: 'POST'
    })
  }
  /** 批量查询指定坐席信息
   * @params {List<number>} 座席工号列表 body true List List
   */
  queryMultiAgentByWorkNo(agentlist) {
    return ajax.request({
      url: `/nagent/device/agent/${this.agentId}/agentinfonoskills`,
      showError: true,
      method: 'POST',
      data: agentlist
    })
  }
  /** 查询配置技能队列座席详细信息
   * @params {List<number>} skillid 技能队列ID
   */
  queryAgentByConfigedSkill(skillid) {
    return Promise.reject('未实现')
  }
  /** 查询签入技能队列座席详细信息
   * @params {String} skillId 技能队列ID
   */
  queryAgentBySkill(skillId) {
    return ajax.request({
      url: `/nagent/device/agent/${this.agentId}/agentbyskill/${skillId}`,
      showError: true,
      method: 'GET'
    }).then(res => {
      res.data.agentDetail = res.result.map(e => {
        e.workno = e.agentId
        return e
      })
      return res
    })
  }
  /** 查询指定状态的坐席信息
   * @params {string} status	Y	座席状态字符串，以“,”分隔（最大长度20）
   */
  queryAgentStatusByStatus(status) {
    return Promise.reject('未实现')
  }
  /** 二次拨号
   * @params {string} dtmf 二次拨号号码(1-24 位数字或*) path
   */
  secondDial(dtmf) {
    return ajax.request({
      url: `/nagent/voice/${this.agentId}/seconddial/${dtmf}`,
      showError: true,
      method: 'POST'
    })
  }
  /** 取消转移 */
  cancelTransfer() {
    return Promise.reject('未实现')
  }
  /** 语音技能统计 */
  voiceSkillStatistic() {
    return Promise.reject('未实现')
  }
  /** 查询空闲状态坐席信息 */
  idleAgent() {
    return ajax.request({
      url: `/nagent/device/agent/${this.agentId}/idleagent`,
      showError: true,
      method: 'GET'
    })
  }
  /** 发送便签
   * @params {List<number>} agentIds	Y	接收者座席工号。最大100个座席工号
   * @params {string} content	Y	便签内容，最大1024个字符

  */
  sendMessageOld(agentIds, content) {
    return Promise.reject('未实现')
  }
  /** 根据呼叫id查询呼叫信息
   * @params {string} callId 呼叫id
   */
  queryCallInfoByCallId(callId) {
    return Promise.reject('未实现')
  }
  /** 释放指定号码连接
   * @params {string} number	Y	待释放的电话号码（1-24位数字）
   */
  releaseSpecificPhone(number) {
    return Promise.reject('未实现')
  }
  /** 查询多个座席人员活动状态的实时监控信息
   * @paraams {List<string>} agentIds Y 坐席工号列表
   */
  queryAgentStatusByAgentids(agentIds) {
    return Promise.reject('未实现')
  }
  // 质检api
  /** 强制签出
   * @params {string} destAgentId 目标座席工号 path true string
   */
  agentForceOut(destAgentId) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/forcelogout/${destAgentId}`,
      showError: true,
      method: 'POST'
    })
  }
  /** 强制示忙
   * @params {string} destAgentId 目标座席工号 path true string
   * @params {string} reason 示忙原因 path true string
   */
  agentForceBusy(destAgentId, reason) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/forcebusy/${destAgentId}/${reason}`,
      showError: true,
      method: 'POST'
    })
  }
  /** 强制示闲
   * @params {string} destAgentId 目标座席工号 path true string
   */
  agentForceIdle(destAgentId) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/forceidle/${destAgentId}`,
      showError: true,
      method: 'POST'
    })
  }
  /** 监听
   * @params {string} destAgentId 被质检的座席工号 path true string
   * @params {string} mediaType 1 为文字质检，5 为语音质检 query false string
   */
  listen(destAgentId, mediaType = 5) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/addsupervise/${destAgentId}`,
      showError: true,
      method: 'POST',
      params: {
        mediaType
      }
    })
  }
  /** 插入
   * @params {string} destAgentId 被质检的座席工号 path true string
   * @params {string} mediaType 1 为文字质检，5 为语音质检 query false string
   */
  insert(destAgentId, mediaType) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/addinsert/${destAgentId}`,
      showError: true,
      method: 'POST',
      params: {
        mediaType
      }
    })
  }
  /** 拦截
   * @params {string} destAgentId 被质检的座席工号 path true string
   * @params {string} mediaType 1 为文字质检，5 为语音质检 query false string
   */
  intercept(destAgentId, mediaType) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/intercept/${destAgentId}`,
      showError: true,
      method: 'POST',
      params: {
        mediaType
      }
    })
  }
  /** 取消侦听和插入
   * @params {string} destAgentId 被质检的座席工号 path true string
   * @params {string} mediaType 1 为文字质检，5 为语音质检 query false string
   */
  cancel(destAgentId, mediaType) {
    return ajax.request({
      url: `/nagent/quality/qualitycontrol/${this.agentId}/${destAgentId}`,
      showError: true,
      method: 'POST',
      params: {
        mediaType
      }
    })
  }
  /** 切换侦听和插入
   * @params switchtype 切换类型（0 表示切换为侦听，1 表示切换为插入，2 表示切换为耳语）query true string
   * @params whisperagentid 被质检的座席工号 query true string
   * @params mediaType mediaType query falseinteger(int32)
   */
  switch(switchtype, whisperagentid, mediaType) {
    return ajax.request({
      url: `/nagent/quality/${this.agentId}/requestswitchinsertwhisperagent`,
      showError: true,
      method: 'POST',
      params: {
        switchtype, whisperagentid, mediaType
      }
    })
  }
  refreshToken() {
    return ajax.request({
      url: `/nagent/online/${this.agentId}/heartbeat`,
      method: 'POST'
    })
  }
}
export const cps = new CallProxyService()
process.env.NODE_ENV === 'development' ? window.$cps2 = cps : ''
export default {
  install(Vue) {
    Object.defineProperty(Vue.prototype, `$callProxyService${cps.callPlatform}`, {
      value: cps
    })
    Object.defineProperty(Vue.prototype, `$cps${cps.callPlatform}`, {
      value: cps
    })
  }
}
